#include "PropiedadesNivel.h"
#include "VentanaDiseniador.h"
#include <gtkmm/label.h>

PropiedadesNivel::LineaSalidaPajaros::LineaSalidaPajaros(
		const struct InfoMov &info) {
	info_generacion = info;
}

PropiedadesNivel::LineaSalidaPajaros::~LineaSalidaPajaros() { }

PropiedadesNivel::PropiedadesNivel() {
	set_row_spacing(3);
	set_column_spacing(5);

	Gtk::Label *etiqueta;

	++contador_id;
	id = contador_id;

	ajuste_anchura = Gtk::Adjustment::create(MIN_ANCHURA_NIVEL,
			MIN_ANCHURA_NIVEL,	MAX_ANCHURA_NIVEL);
	d_SpinButton_anchura.set_adjustment(ajuste_anchura);
	d_SpinButton_anchura.set_wrap();
	d_SpinButton_anchura.set_numeric();
	d_SpinButton_anchura.set_alignment(Gtk::ALIGN_CENTER);
	d_SpinButton_anchura.set_update_policy(Gtk::UPDATE_IF_VALID);
	d_SpinButton_anchura.signal_value_changed().connect(
			sigc::mem_fun(*this, &PropiedadesNivel::on_anchura_value_changed));

	ajuste_altura = Gtk::Adjustment::create(MIN_ALTURA_NIVEL, MIN_ALTURA_NIVEL,
			MAX_ALTURA_NIVEL);
	d_SpinButton_altura.set_adjustment(ajuste_altura);
	d_SpinButton_altura.set_wrap();
	d_SpinButton_altura.set_numeric();
	d_SpinButton_altura.set_alignment(Gtk::ALIGN_CENTER);
	d_SpinButton_altura.set_update_policy(Gtk::UPDATE_IF_VALID);
	d_SpinButton_altura.signal_value_changed().connect(
			sigc::mem_fun(*this, &PropiedadesNivel::on_altura_value_changed));

	ajuste_tiempo = Gtk::Adjustment::create(MIN_TIEMPO_NIVEL, MIN_TIEMPO_NIVEL, 
			MAX_TIEMPO_NIVEL);
	d_SpinButton_tiempo.set_adjustment(ajuste_tiempo);
	d_SpinButton_tiempo.set_wrap();
	d_SpinButton_tiempo.set_numeric();
	d_SpinButton_tiempo.set_alignment(Gtk::ALIGN_CENTER);
	d_SpinButton_tiempo.set_update_policy(Gtk::UPDATE_IF_VALID);

	Glib::RefPtr<Gtk::FileFilter> filtroImagenes = Gtk::FileFilter::create();
	filtroImagenes->set_name("Image files");
	filtroImagenes->add_mime_type("image/png");
	d_FileChooserButton_imagen.set_action(Gtk::FILE_CHOOSER_ACTION_OPEN);
	d_FileChooserButton_imagen.add_filter(filtroImagenes);
	d_FileChooserButton_imagen.set_title("Seleccionar Imagen");
	d_FileChooserButton_imagen.set_filename(RUTA_IMAGEN_FONDO_DEFECTO);
	d_FileChooserButton_imagen.set_width_chars(14);
	d_FileChooserButton_imagen.signal_file_set().connect(
			sigc::mem_fun(*this, &PropiedadesNivel::on_file_set));

	d_Button_salidaPajaros.set_label("Generacion Pajaros");
	d_Button_salidaPajaros.signal_clicked().connect(sigc::mem_fun(
			*this, &PropiedadesNivel::on_button_generador_clicked));

	d_Button_piso.set_label("Generacion Piso");
	d_Button_piso.signal_clicked().connect(sigc::mem_fun(
			*this, &PropiedadesNivel::on_button_piso_clicked));

	etiqueta = Gtk::manage(
			new Gtk::Label("PROPIEDADES DEL NIVEL", Gtk::ALIGN_CENTER));
	attach(*etiqueta, 0, 0, 2, 1);

	char buffer[10];
	sprintf(buffer, "Nivel %d", id);
	Glib::ustring texto_etiqueta(buffer);

	d_Label_idNivel = new Gtk::Label(texto_etiqueta, Gtk::ALIGN_CENTER);
	attach(*d_Label_idNivel, 0, 1, 2, 1);

	etiqueta = Gtk::manage(new Gtk::Label("Imagen de Fondo", Gtk::ALIGN_END));
	attach(*etiqueta, 0, 2, 1, 1);
	attach_next_to(d_FileChooserButton_imagen, *etiqueta, Gtk::POS_RIGHT, 1, 1);

	etiqueta = Gtk::manage(new Gtk::Label("Anchura (pixeles)", Gtk::ALIGN_END));
	attach(*etiqueta, 0, 3, 1, 1);
	attach_next_to(d_SpinButton_anchura, *etiqueta, Gtk::POS_RIGHT, 1, 1);

	etiqueta = Gtk::manage(new Gtk::Label("Altura (pixeles)", Gtk::ALIGN_END));
	attach(*etiqueta, 0, 4, 1, 1);
	attach_next_to(d_SpinButton_altura, *etiqueta, Gtk::POS_RIGHT, 1, 1);

	etiqueta = Gtk::manage(new Gtk::Label("Tiempo (seg)", Gtk::ALIGN_END));
	attach(*etiqueta, 0, 5, 1, 1);
	attach_next_to(d_SpinButton_tiempo, *etiqueta, Gtk::POS_RIGHT, 1, 1);

	attach(d_Button_salidaPajaros, 0, 6, 1, 1);
	attach(d_Button_piso, 1, 6, 1, 1);

	lienzo_nivel = new Lienzo;
	d_window_salidaPajaros = new VentanaSalidaPajaros(this);
	d_window_piso = new VentanaPiso(this);
}

unsigned PropiedadesNivel::getId() const {
	return id;
}

void PropiedadesNivel::decId() {
	--id;
	delete d_Label_idNivel;
	char buffer[10];
	sprintf(buffer, "Nivel %d", id);
	Glib::ustring texto_etiqueta(buffer);
	d_Label_idNivel = new Gtk::Label(texto_etiqueta, Gtk::ALIGN_CENTER);
	attach(*d_Label_idNivel, 0, 1, 2, 1);
}

void PropiedadesNivel::resetarContadorId() {
	contador_id = 0;
}

Lienzo* PropiedadesNivel::getLienzoNivel() const {
	return lienzo_nivel;
}

unsigned PropiedadesNivel::getMaxAnchura() const {
	return ((unsigned)d_SpinButton_anchura.get_value_as_int() - 1);
}

unsigned PropiedadesNivel::getMaxAltura() const {
	return ((unsigned)d_SpinButton_altura.get_value_as_int() - 1);
}

void PropiedadesNivel::agregarLineaSalidaPajaros(const struct InfoMov &info) {
	LineaSalidaPajaros *nuevaLinea = new LineaSalidaPajaros(info);
	vec_salidaPajaros.push_back(nuevaLinea);

	/* Agrego la linea para que se dibuje en el lienzo */
	lienzo_nivel->agregarLineaPajaros(info._pXm, info._pYm, info._pXM,
			info._pYM);
	lienzo_nivel->queue_draw();
}

void PropiedadesNivel::agregarPiso(Piso *piso) {
	vec_pisos.push_back(piso);
	const std::vector<Posicion*> vec_posiciones = piso->getVectorPosiciones();
	unsigned posXinicial, posYinicial, posXfinal, posYfinal;

	for (unsigned i = 0; i < vec_posiciones.size() - 1; ++i) {
		posXinicial = vec_posiciones[i]->X();
		posYinicial = vec_posiciones[i]->Y();
		posXfinal = vec_posiciones[i + 1]->X();
		posYfinal = vec_posiciones[i + 1]->Y();

		/* Agrego la linea para que se dibuje en el lienzo */
		lienzo_nivel->agregarLineaPiso(posXinicial, posYinicial, posXfinal,
				posYfinal);
	}

	lienzo_nivel->queue_draw();
}

Nivel* PropiedadesNivel::guardar() {
	unsigned anchura = (unsigned)d_SpinButton_anchura.get_value_as_int();
	unsigned altura = (unsigned)d_SpinButton_altura.get_value_as_int();
	unsigned tiempo = (unsigned)d_SpinButton_tiempo.get_value_as_int();
	std::string rutaImagen = d_FileChooserButton_imagen.get_filename();
	rutaImagen = rutaImagen.substr(rutaImagen.find_last_of('/') + 1);
	Nivel* nivel = new Nivel(id, anchura, altura, tiempo, rutaImagen);
	struct InfoMov *info;
	if (nivel != NULL) {
		if (vec_pisos.size() == 0) {
			Piso *piso = new Piso;
			piso->addPunto(new Posicion(0, getMaxAltura()));
			piso->addPunto(new Posicion(getMaxAnchura(), getMaxAltura()));
			vec_pisos.push_back(piso);
		}
		for (unsigned i = 0; i < vec_pisos.size(); ++i) {
			nivel->getEscenario()->addUtilidad(vec_pisos[i]->clonar(),
					new Posicion(0, 0));
		}

		lienzo_nivel->guardar(nivel->getEscenario());
		for (unsigned i = 0; i < vec_salidaPajaros.size(); ++i) {
			info = new struct InfoMov;
			*info = vec_salidaPajaros[i]->info_generacion;
			nivel->getEscenario()->setSemillaGeneradorPajaritos(info);
		}
	}
	return nivel;
}

void PropiedadesNivel::cargar(Nivel *nivel) {
	eliminarSalidasPajaros();
	eliminarPiso();
	id = nivel->getId();
	std::string rutaImagen(RUTA_CARPETA_RECURSOS + nivel->getEscenario(
			)->getRutaImagenFondo());
	d_FileChooserButton_imagen.set_filename(rutaImagen);
	ajuste_anchura->set_value(nivel->getEscenario()->getPerimetro()->getAncho());
	ajuste_altura->set_value(nivel->getEscenario()->getPerimetro()->getAlto());
	ajuste_tiempo->set_value(nivel->getTiempo());

	std::vector<InfoMov*> vec_info = nivel->getEscenario(
			)->getSemillasGeneradorPajaritos();
	for (unsigned i = 0; i < vec_info.size(); ++i) {
		agregarLineaSalidaPajaros(*(vec_info[i]));
	}

	std::vector<Piso*> vec_piso;
	nivel->getEscenario()->getVectorPisos(vec_piso);
	for (unsigned i = 0; i < vec_piso.size(); ++i) {
		agregarPiso(vec_piso[i]);
	}

	lienzo_nivel->setImagenFondo(rutaImagen);
	lienzo_nivel->cargar(nivel->getEscenario());
}

void PropiedadesNivel::eliminarSalidasPajaros() {
	for (unsigned i = 0; i < vec_salidaPajaros.size(); ++i) {
		delete (vec_salidaPajaros[i]);
	}
	vec_salidaPajaros.clear();
}

void PropiedadesNivel::eliminarPiso() {
	for (unsigned i = 0; i < vec_pisos.size(); ++i) {
		delete vec_pisos[i];
	}
	vec_pisos.clear();
}

void PropiedadesNivel::on_file_set() {
	lienzo_nivel->setImagenFondo(d_FileChooserButton_imagen.get_filename());
}

void PropiedadesNivel::on_anchura_value_changed() {
	lienzo_nivel->setAnchura((unsigned)d_SpinButton_anchura.get_value_as_int());
}

void PropiedadesNivel::on_altura_value_changed() {
	lienzo_nivel->setAltura((unsigned)d_SpinButton_altura.get_value_as_int());
}

void PropiedadesNivel::on_button_generador_clicked() {
	if (d_window_salidaPajaros == NULL) {
		d_window_salidaPajaros = new VentanaSalidaPajaros(this);
	}
	else {

		d_window_salidaPajaros->resetear();
	}
	d_window_salidaPajaros->show();
}

void PropiedadesNivel::on_button_piso_clicked() {
	if (d_window_piso == NULL) {
		d_window_piso = new VentanaPiso(this);
	}
	else {

		d_window_piso->resetear();
	}
	d_window_piso->show();
}

PropiedadesNivel::~PropiedadesNivel() {
	eliminarSalidasPajaros();
	eliminarPiso();
	if (d_window_salidaPajaros != NULL) {
		delete d_window_salidaPajaros;
	}
	if (d_window_piso != NULL) {
		delete d_window_piso;
	}
	if (lienzo_nivel != NULL) {
		delete lienzo_nivel;
	}
	delete d_Label_idNivel;
	--contador_id;
}

unsigned PropiedadesNivel::contador_id = 0;